package com.rd.server.modules.login.service.impl;

import cn.dev33.satoken.stp.SaTokenInfo;
import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.rd.common.utils.AvatarBase64Util;
import com.rd.common.utils.FileDownloadUtil;
import com.rd.modules.user.model.ao.UserAO;
import com.rd.server.modules.login.service.LoginService;
import com.rd.server.modules.user.model.po.UserPO;
import com.rd.server.modules.user.service.UserService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import java.util.Date;

@Slf4j
@Service
@RequiredArgsConstructor
public class LoginServiceImpl implements LoginService {

    /**
     * 域名
     */
    public static final String DOMAIN = "https://www.oj8k.icu";

    private final UserService userService;


    @Override
    public SaTokenInfo wxLogin(UserAO userAO) {
        // 获取微信用户openId和sessionKey
        String openId = userAO.getOpenId();
        UserPO userPO = userService.selectByOpenId(openId);

        if (ObjectUtils.isEmpty(userPO)) {
            // 用户未注册，先注册
            userPO = new UserPO();
            BeanUtils.copyProperties(userAO, userPO);

            // 设置注册时间和创建时间
            Date now = new Date();
            userPO.setRegisterTime(now);
            userPO.setCreatedAt(now);

            // 关键：先生成ID
            userPO.setId(IdUtil.getSnowflakeNextIdStr());

            // 处理新用户头像下载 - 传入 userAO 参数
//            handleAvatarDownload(userPO, userAO.getAvatar(), true, userAO);

            // 保存用户到数据库
            userService.save(userPO);
            log.info("新用户注册成功，用户ID: {}, 昵称: {}, 头像路径: {}",
                    userPO.getId(), userPO.getNickname(), userPO.getAvatar());
        } else {
            // 用户已存在，检查是否需要更新头像 - 传入 userAO 参数
//            handleAvatarDownload(userPO, userAO.getAvatar(), false, userAO);
            userPO.setAvatar(userAO.getAvatar());
            userPO.setNickname(userAO.getNickname());
            userService.updateById(userPO);
        }

        // 第1步，先登录上
        StpUtil.login(userPO.getId());

        // 第2步，获取 Token 相关参数
        SaTokenInfo tokenInfo = StpUtil.getTokenInfo();
        tokenInfo.setTag(userPO.getNickname());

        // 第3步，返回给前端
        return tokenInfo;
    }

    /**
     * 处理头像下载逻辑
     *
     * @param userPO    用户实体对象
     * @param avatarUrl 头像URL
     * @param isNewUser 是否新用户
     * @param userAO    用户请求对象（包含 Base64 头像数据）
     */
    private void handleAvatarDownload(UserPO userPO, String avatarUrl, boolean isNewUser, UserAO userAO) {
        // 优先处理 Base64 头像
        if (StrUtil.isNotBlank(userAO.getAvatarBase())) {
            handleBase64Avatar(userPO, userAO.getAvatarBase(), isNewUser);
            return;
        }

        // 如果没有 Base64 头像，则处理 URL 头像
        if (StrUtil.isBlank(avatarUrl)) {
            log.debug("头像URL为空，跳过下载处理");
            return;
        }

        try {
            if (isNewUser) {
                // 新用户头像下载
                downloadAvatarForNewUser(userPO, avatarUrl);
            } else {
                // 老用户头像更新
                updateAvatarForExistingUser(userPO, avatarUrl);
            }
        } catch (Exception e) {
            log.error("处理头像下载时发生异常: {}", avatarUrl, e);
        }
    }

    /**
     * 处理 Base64 头像
     *
     * @param userPO     用户实体对象
     * @param avatarBase Base64 头像数据
     * @param isNewUser  是否新用户
     */
    private void handleBase64Avatar(UserPO userPO, String avatarBase, boolean isNewUser) {
        try {
            if (isNewUser) {
                // 新用户保存 Base64 头像
                saveBase64AvatarForNewUser(userPO, avatarBase);
            } else {
                // 老用户更新 Base64 头像
                updateBase64AvatarForExistingUser(userPO, avatarBase);
            }
        } catch (Exception e) {
            log.error("处理Base64头像时发生异常", e);
        }
    }

    /**
     * 为新用户保存 Base64 头像
     *
     * @param userPO     用户实体对象
     * @param avatarBase Base64 头像数据
     */
    private void saveBase64AvatarForNewUser(UserPO userPO, String avatarBase) {
        try {
            String localAvatarPath = AvatarBase64Util.saveBase64Avatar(avatarBase, userPO.getId());
            if (localAvatarPath != null) {
                // 将本地头像路径保存到用户对象中
                userPO.setAvatar(DOMAIN + AvatarBase64Util.convertToWebPath(localAvatarPath));
                log.info("新用户Base64头像保存成功，本地路径: {}", localAvatarPath);
            } else {
                // 保存失败，记录警告
                log.warn("新用户Base64头像保存失败");
            }
        } catch (Exception e) {
            log.error("保存新用户Base64头像时发生异常", e);
        }
    }

    /**
     * 为老用户更新 Base64 头像
     *
     * @param userPO     用户实体对象
     * @param avatarBase Base64 头像数据
     */
    private void updateBase64AvatarForExistingUser(UserPO userPO, String avatarBase) {
        // 删除旧的头像文件
        deleteOldAvatar(userPO.getAvatar());

        // 保存新头像
        try {
            String localAvatarPath = AvatarBase64Util.saveBase64Avatar(avatarBase, userPO.getId());
            if (localAvatarPath != null) {
                // 更新用户头像路径并保存到数据库
                userPO.setAvatar(DOMAIN + AvatarBase64Util.convertToWebPath(localAvatarPath));
                userService.updateById(userPO);
                log.info("用户Base64头像更新成功，本地路径: {}", localAvatarPath);
            }
        } catch (Exception e) {
            log.error("更新用户Base64头像时发生异常", e);
        }
    }

    /**
     * 为新用户下载头像
     *
     * @param userPO    用户实体对象
     * @param avatarUrl 头像URL
     */
    private void downloadAvatarForNewUser(UserPO userPO, String avatarUrl) {
        try {
            String localAvatarPath = FileDownloadUtil.downloadAvatar(avatarUrl, userPO.getId());
            if (localAvatarPath != null) {
                // 将本地头像路径保存到用户对象中
                userPO.setAvatar(DOMAIN + localAvatarPath);
                log.info("新用户头像下载成功，本地路径: {}", localAvatarPath);
            } else {
                // 下载失败，保持原始URL
                log.warn("新用户头像下载失败，保持原始URL: {}", avatarUrl);
            }
        } catch (Exception e) {
            log.error("下载新用户头像时发生异常: {}", avatarUrl, e);
        }
    }

    /**
     * 为老用户更新头像
     *
     * @param userPO    用户实体对象
     * @param avatarUrl 头像URL
     */
    private void updateAvatarForExistingUser(UserPO userPO, String avatarUrl) {
        // 检查是否需要更新头像
        if (needUpdateAvatar(userPO, avatarUrl)) {
            // 删除旧的头像文件
            deleteOldAvatar(userPO.getAvatar());

            // 下载新头像
            try {
                String localAvatarPath = FileDownloadUtil.downloadAvatar(avatarUrl, userPO.getId());
                if (localAvatarPath != null) {
                    // 更新用户头像路径并保存到数据库
                    userPO.setAvatar(DOMAIN + localAvatarPath);
                    userService.updateById(userPO);
                    log.info("用户头像更新成功，本地路径: {}", localAvatarPath);
                }
            } catch (Exception e) {
                log.error("更新用户头像时发生异常: {}", avatarUrl, e);
            }
        }
    }

    /**
     * 检查是否需要更新头像
     *
     * @param userPO    用户实体对象
     * @param avatarUrl 头像URL
     * @return 是否需要更新
     */
    private boolean needUpdateAvatar(UserPO userPO, String avatarUrl) {
        // 检查URL是否变化
        if (!avatarUrl.equals(userPO.getAvatar())) {
            return true;
        }

        // 检查本地文件是否存在
        if (FileDownloadUtil.isUserAvatarFile(userPO.getAvatar()) && !FileDownloadUtil.fileExists(userPO.getAvatar())) {
            log.info("本地头像文件不存在，需要重新下载: {}", userPO.getAvatar());
            return true;
        }

        return false;
    }

    /**
     * 删除旧的头像文件
     *
     * @param avatarPath 头像路径
     */
    private void deleteOldAvatar(String avatarPath) {
        if (FileDownloadUtil.isUserAvatarFile(avatarPath)) {
            if (FileDownloadUtil.deleteAvatar(avatarPath)) {
                log.info("删除旧头像文件成功: {}", avatarPath);
            } else {
                log.warn("删除旧头像文件失败: {}", avatarPath);
            }
        }
    }
}